home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 April: Mac OS SDK / Dev.CD Apr 99 SDK1.toast / Development Kits / Interfaces&Libraries / Universal / Interfaces / PInterfaces / TextEdit.p < prev    next >
Encoding:
Text File  |  1998-08-17  |  31.3 KB  |  885 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        TextEdit.p
  3.  
  4.      Contains:    TextEdit Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.2
  8.  
  9.      Copyright:    © 1985-1998 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. }
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT TextEdit;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __TEXTEDIT__}
  27. {$SETC __TEXTEDIT__ := 1}
  28.  
  29. {$I+}
  30. {$SETC TextEditIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33. {$IFC UNDEFINED __MACTYPES__}
  34. {$I MacTypes.p}
  35. {$ENDC}
  36. {$IFC UNDEFINED __QUICKDRAW__}
  37. {$I Quickdraw.p}
  38. {$ENDC}
  39. {$IFC UNDEFINED __MIXEDMODE__}
  40. {$I MixedMode.p}
  41. {$ENDC}
  42.  
  43.  
  44. {$PUSH}
  45. {$ALIGN MAC68K}
  46. {$LibExport+}
  47.  
  48.  
  49. TYPE
  50.     TERecPtr = ^TERec;
  51.     TEPtr                                = ^TERec;
  52.     TEHandle                            = ^TEPtr;
  53. {$IFC TYPED_FUNCTION_POINTERS}
  54.     HighHookProcPtr = PROCEDURE({CONST}VAR r: Rect; pTE: TEPtr);
  55. {$ELSEC}
  56.     HighHookProcPtr = Register68kProcPtr;
  57. {$ENDC}
  58.  
  59. {$IFC TYPED_FUNCTION_POINTERS}
  60.     EOLHookProcPtr = FUNCTION(theChar: ByteParameter; pTE: TEPtr; hTE: TEHandle): BOOLEAN;
  61. {$ELSEC}
  62.     EOLHookProcPtr = Register68kProcPtr;
  63. {$ENDC}
  64.  
  65. {$IFC TYPED_FUNCTION_POINTERS}
  66.     CaretHookProcPtr = PROCEDURE({CONST}VAR r: Rect; pTE: TEPtr);
  67. {$ELSEC}
  68.     CaretHookProcPtr = Register68kProcPtr;
  69. {$ENDC}
  70.  
  71. {$IFC TYPED_FUNCTION_POINTERS}
  72.     WidthHookProcPtr = FUNCTION(textLen: UInt16; textOffset: UInt16; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle): UInt16;
  73. {$ELSEC}
  74.     WidthHookProcPtr = Register68kProcPtr;
  75. {$ENDC}
  76.  
  77. {$IFC TYPED_FUNCTION_POINTERS}
  78.     TextWidthHookProcPtr = FUNCTION(textLen: UInt16; textOffset: UInt16; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle): UInt16;
  79. {$ELSEC}
  80.     TextWidthHookProcPtr = Register68kProcPtr;
  81. {$ENDC}
  82.  
  83. {$IFC TYPED_FUNCTION_POINTERS}
  84.     NWidthHookProcPtr = FUNCTION(styleRunLen: UInt16; styleRunOffset: UInt16; slop: INTEGER; direction: INTEGER; textBufferPtr: UNIV Ptr; VAR lineStart: INTEGER; pTE: TEPtr; hTE: TEHandle): UInt16;
  85. {$ELSEC}
  86.     NWidthHookProcPtr = Register68kProcPtr;
  87. {$ENDC}
  88.  
  89. {$IFC TYPED_FUNCTION_POINTERS}
  90.     DrawHookProcPtr = PROCEDURE(textOffset: UInt16; drawLen: UInt16; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle);
  91. {$ELSEC}
  92.     DrawHookProcPtr = Register68kProcPtr;
  93. {$ENDC}
  94.  
  95. {$IFC TYPED_FUNCTION_POINTERS}
  96.     HitTestHookProcPtr = FUNCTION(styleRunLen: UInt16; styleRunOffset: UInt16; slop: UInt16; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; VAR pixelWidth: UInt16; VAR charOffset: UInt16; VAR pixelInChar: BOOLEAN): BOOLEAN;
  97. {$ELSEC}
  98.     HitTestHookProcPtr = Register68kProcPtr;
  99. {$ENDC}
  100.  
  101. {$IFC TYPED_FUNCTION_POINTERS}
  102.     TEFindWordProcPtr = PROCEDURE(currentPos: UInt16; caller: INTEGER; pTE: TEPtr; hTE: TEHandle; VAR wordStart: UInt16; VAR wordEnd: UInt16);
  103. {$ELSEC}
  104.     TEFindWordProcPtr = Register68kProcPtr;
  105. {$ENDC}
  106.  
  107. {$IFC TYPED_FUNCTION_POINTERS}
  108.     TERecalcProcPtr = PROCEDURE(pTE: TEPtr; changeLength: UInt16; VAR lineStart: UInt16; VAR firstChar: UInt16; VAR lastChar: UInt16);
  109. {$ELSEC}
  110.     TERecalcProcPtr = Register68kProcPtr;
  111. {$ENDC}
  112.  
  113. {$IFC TYPED_FUNCTION_POINTERS}
  114.     TEDoTextProcPtr = PROCEDURE(pTE: TEPtr; firstChar: UInt16; lastChar: UInt16; selector: INTEGER; VAR currentGrafPort: GrafPtr; VAR charPosition: INTEGER);
  115. {$ELSEC}
  116.     TEDoTextProcPtr = Register68kProcPtr;
  117. {$ENDC}
  118.  
  119. {$IFC TYPED_FUNCTION_POINTERS}
  120.     TEClickLoopProcPtr = FUNCTION(pTE: TEPtr): BOOLEAN;
  121. {$ELSEC}
  122.     TEClickLoopProcPtr = Register68kProcPtr;
  123. {$ENDC}
  124.  
  125. {$IFC TYPED_FUNCTION_POINTERS}
  126.     WordBreakProcPtr = FUNCTION(text: Ptr; charPos: INTEGER): BOOLEAN;
  127. {$ELSEC}
  128.     WordBreakProcPtr = Register68kProcPtr;
  129. {$ENDC}
  130.  
  131. { 
  132.     Important note about TEClickLoopProcPtr and WordBreakProcPtr
  133.  
  134.     At one point these were defined as returning the function result in the 
  135.     condition code Z-bit.  This was correct, in that it was what the 68K
  136.     implementation of TextEdit actually tested.  But, MixedMode had a different 
  137.     idea of what returning a boolean in the Z-bit meant.  MixedMode was setting
  138.     the Z-bit the complement of what was wanted.  
  139.     
  140.     Therefore, these ProcPtrs have been changed (back) to return the result in
  141.     register D0.  It turns out that for register based routines, 
  142.     MixedMode sets the Z-bit of the 68K emulator based on the contents 
  143.     of the return result register.  Thus we can get the Z-bit set correctly.  
  144.     
  145.     But, when TextEdit is recoded in PowerPC, if it calls a 68K ClickLoop
  146.     or WordBreak routine, register D0 had better have the result (in addition
  147.     to the Z-bit). Therefore all 68K apps should make sure their ClickLoop or
  148.     WordBreak routines set register D0 at the end.
  149. }
  150.  
  151. { 
  152.     There is no function to get/set the low-mem for FindWordHook at 0x07F8.
  153.     This is because it is not a low-mem ProcPtr. That address is the entry
  154.     in the OS TrapTable for trap 0xA0FE.  You can use Get/SetTrapAddress to 
  155.     acccess it.    
  156. }
  157.  
  158. {
  159.     The following ProcPtrs cannot be written in or called from a high-level 
  160.     language without the help of mixed mode or assembly glue because they 
  161.     use the following parameter-passing conventions:
  162.  
  163.     typedef pascal void (*HighHookProcPtr)(const Rect *r, TEPtr pTE);
  164.     typedef pascal void (*CaretHookProcPtr)(const Rect *r, TEPtr pTE);
  165.  
  166.         In:
  167.             =>     r                        on stack
  168.             =>    pTE                        A3.L
  169.         Out:
  170.             none
  171.  
  172.     typedef pascal Boolean (*EOLHookProcPtr)(char theChar, TEPtr pTE, TEHandle hTE);
  173.  
  174.         In:
  175.             =>     theChar                    D0.B
  176.             =>    pTE                        A3.L
  177.             =>    hTE                        A4.L
  178.         Out:
  179.             <=    Boolean                    Z bit of the CCR
  180.  
  181.     typedef pascal unsigned short (*WidthHookProcPtr)(unsigned short textLen,
  182.      unsigned short textOffset, void *textBufferPtr, TEPtr pTE, TEHandle hTE);
  183.     typedef pascal unsigned short (*TextWidthHookProcPtr)(unsigned short textLen,
  184.      unsigned short textOffset, void *textBufferPtr, TEPtr pTE, TEHandle hTE);
  185.  
  186.         In:
  187.             =>     textLen                    D0.W
  188.             =>    textOffset                D1.W
  189.             =>    textBufferPtr            A0.L
  190.             =>    pTE                        A3.L
  191.             =>    hTE                        A4.L
  192.         Out:
  193.             <=    unsigned short            D1.W
  194.  
  195.     typedef pascal unsigned short (*NWidthHookProcPtr)(unsigned short styleRunLen,
  196.      unsigned short styleRunOffset, short slop, short direction, void *textBufferPtr, 
  197.      short *lineStart, TEPtr pTE, TEHandle hTE);
  198.  
  199.         In:
  200.             =>     styleRunLen                D0.W
  201.             =>    styleRunOffset            D1.W
  202.             =>    slop                    D2.W (low)
  203.             =>    direction                D2.W (high)
  204.             =>    textBufferPtr            A0.L
  205.             =>    lineStart                A2.L
  206.             =>    pTE                        A3.L
  207.             =>    hTE                        A4.L
  208.         Out:
  209.             <=    unsigned short            D1.W
  210.  
  211.     typedef pascal void (*DrawHookProcPtr)(unsigned short textOffset, unsigned short drawLen,
  212.      void *textBufferPtr, TEPtr pTE, TEHandle hTE);
  213.  
  214.         In:
  215.             =>     textOffset                D0.W
  216.             =>    drawLen                    D1.W
  217.             =>    textBufferPtr            A0.L
  218.             =>    pTE                        A3.L
  219.             =>    hTE                        A4.L
  220.         Out:
  221.             none
  222.  
  223.     typedef pascal Boolean (*HitTestHookProcPtr)(unsigned short styleRunLen,
  224.      unsigned short styleRunOffset, unsigned short slop, void *textBufferPtr,
  225.      TEPtr pTE, TEHandle hTE, unsigned short *pixelWidth, unsigned short *charOffset, 
  226.      Boolean *pixelInChar);
  227.  
  228.         In:
  229.             =>     styleRunLen                D0.W
  230.             =>    styleRunOffset            D1.W
  231.             =>    slop                    D2.W
  232.             =>    textBufferPtr            A0.L
  233.             =>    pTE                        A3.L
  234.             =>    hTE                        A4.L
  235.         Out:
  236.             <=    pixelWidth                D0.W (low)
  237.             <=    Boolean                    D0.W (high)
  238.             <=    charOffset                D1.W
  239.             <=    pixelInChar                D2.W
  240.  
  241.     typedef pascal void (*TEFindWordProcPtr)(unsigned short currentPos, short caller, 
  242.      TEPtr pTE, TEHandle hTE, unsigned short *wordStart, unsigned short *wordEnd);
  243.  
  244.         In:
  245.             =>     currentPos                D0.W
  246.             =>    caller                    D2.W
  247.             =>    pTE                        A3.L
  248.             =>    hTE                        A4.L
  249.         Out:
  250.             <=    wordStart                D0.W
  251.             <=    wordEnd                    D1.W
  252.  
  253.     typedef pascal void (*TERecalcProcPtr)(TEPtr pTE, unsigned short changeLength,
  254.        unsigned short *lineStart, unsigned short *firstChar, unsigned short *lastChar);
  255.  
  256.         In:
  257.             =>     pTE                        A3.L
  258.             =>    changeLength            D7.W
  259.         Out:
  260.             <=    lineStart                D2.W
  261.             <=    firstChar                D3.W
  262.             <=    lastChar                D4.W
  263.  
  264.     typedef pascal void (*TEDoTextProcPtr)(TEPtr pTE, unsigned short firstChar, unsigned short lastChar,
  265.                          short selector, GrafPtr *currentGrafPort, short *charPosition);
  266.  
  267.         In:
  268.             =>     pTE                        A3.L
  269.             =>    firstChar                D3.W
  270.             =>    lastChar                D4.W
  271.             =>    selector                D7.W
  272.         Out:
  273.             <=    currentGrafPort            A0.L
  274.             <=    charPosition            D0.W
  275.             
  276. }
  277.     HighHookUPP = UniversalProcPtr;
  278.     EOLHookUPP = UniversalProcPtr;
  279.     CaretHookUPP = UniversalProcPtr;
  280.     WidthHookUPP = UniversalProcPtr;
  281.     TextWidthHookUPP = UniversalProcPtr;
  282.     NWidthHookUPP = UniversalProcPtr;
  283.     DrawHookUPP = UniversalProcPtr;
  284.     HitTestHookUPP = UniversalProcPtr;
  285.     TEFindWordUPP = UniversalProcPtr;
  286.     TERecalcUPP = UniversalProcPtr;
  287.     TEDoTextUPP = UniversalProcPtr;
  288.     TEClickLoopUPP = UniversalProcPtr;
  289.     WordBreakUPP = UniversalProcPtr;
  290.     TERec = RECORD
  291.         destRect:                Rect;
  292.         viewRect:                Rect;
  293.         selRect:                Rect;
  294.         lineHeight:                INTEGER;
  295.         fontAscent:                INTEGER;
  296.         selPoint:                Point;
  297.         selStart:                INTEGER;
  298.         selEnd:                    INTEGER;
  299.         active:                    INTEGER;
  300.         wordBreak:                WordBreakUPP;
  301.         clickLoop:                TEClickLoopUPP;
  302.         clickTime:                LONGINT;
  303.         clickLoc:                INTEGER;
  304.         caretTime:                LONGINT;
  305.         caretState:                INTEGER;
  306.         just:                    INTEGER;
  307.         teLength:                INTEGER;
  308.         hText:                    Handle;
  309.         hDispatchRec:            LONGINT;                                {  added to replace recalBack & recalLines.  it's a handle anyway  }
  310.         clikStuff:                INTEGER;
  311.         crOnly:                    INTEGER;
  312.         txFont:                    INTEGER;
  313.         txFace:                    StyleField;                                { txFace is unpacked byte }
  314.         txMode:                    INTEGER;
  315.         txSize:                    INTEGER;
  316.         inPort:                    GrafPtr;
  317.         highHook:                HighHookUPP;
  318.         caretHook:                CaretHookUPP;
  319.         nLines:                    INTEGER;
  320.         lineStarts:                ARRAY [0..16000] OF INTEGER;
  321.     END;
  322.  
  323.  
  324. CONST
  325.                                                                 {  Justification (word alignment) styles  }
  326.     teJustLeft                    = 0;
  327.     teJustCenter                = 1;
  328.     teJustRight                    = -1;
  329.     teForceLeft                    = -2;                            {  new names for the Justification (word alignment) styles  }
  330.     teFlushDefault                = 0;                            { flush according to the line direction  }
  331.     teCenter                    = 1;                            { center justify (word alignment)  }
  332.     teFlushRight                = -1;                            { flush right for all scripts  }
  333.     teFlushLeft                    = -2;                            { flush left for all scripts  }
  334.  
  335.                                                                 {  Set/Replace style modes  }
  336.     fontBit                        = 0;                            { set font }
  337.     faceBit                        = 1;                            { set face }
  338.     sizeBit                        = 2;                            { set size }
  339.     clrBit                        = 3;                            { set color }
  340.     addSizeBit                    = 4;                            { add size mode }
  341.     toggleBit                    = 5;                            { set faces in toggle mode }
  342.  
  343.                                                                 {  TESetStyle/TEContinuousStyle modes  }
  344.     doFont                        = 1;                            {  set font (family) number }
  345.     doFace                        = 2;                            { set character style }
  346.     doSize                        = 4;                            { set type size }
  347.     doColor                        = 8;                            { set color }
  348.     doAll                        = 15;                            { set all attributes }
  349.     addSize                        = 16;                            { adjust type size }
  350.     doToggle                    = 32;                            { toggle mode for TESetStyle }
  351.  
  352.                                                                 {  offsets into TEDispatchRec  }
  353.     EOLHook                        = 0;                            { [UniversalProcPtr] TEEOLHook }
  354.     DRAWHook                    = 4;                            { [UniversalProcPtr] TEWidthHook }
  355.     WIDTHHook                    = 8;                            { [UniversalProcPtr] TEDrawHook }
  356.     HITTESTHook                    = 12;                            { [UniversalProcPtr] TEHitTestHook }
  357.     nWIDTHHook                    = 24;                            { [UniversalProcPtr] nTEWidthHook }
  358.     TextWidthHook                = 28;                            { [UniversalProcPtr] TETextWidthHook }
  359.  
  360.                                                                 {  selectors for TECustomHook  }
  361.     intEOLHook                    = 0;                            { TEIntHook value }
  362.     intDrawHook                    = 1;                            { TEIntHook value }
  363.     intWidthHook                = 2;                            { TEIntHook value }
  364.     intHitTestHook                = 3;                            { TEIntHook value }
  365.     intNWidthHook                = 6;                            { TEIntHook value for new version of WidthHook }
  366.     intTextWidthHook            = 7;                            { TEIntHook value for new TextWidthHook }
  367.     intInlineInputTSMTEPreUpdateHook = 8;                        { TEIntHook value for TSMTEPreUpdateProcPtr callback }
  368.     intInlineInputTSMTEPostUpdateHook = 9;                        { TEIntHook value for TSMTEPostUpdateProcPtr callback }
  369.  
  370.                                                                 {  feature or bit definitions for TEFeatureFlag  }
  371.     teFAutoScroll                = 0;                            { 00000001b }
  372.     teFTextBuffering            = 1;                            { 00000010b }
  373.     teFOutlineHilite            = 2;                            { 00000100b }
  374.     teFInlineInput                = 3;                            { 00001000b  }
  375.     teFUseWhiteBackground        = 4;                            { 00010000b  }
  376.     teFUseInlineInput            = 5;                            { 00100000b  }
  377.     teFInlineInputAutoScroll    = 6;                            { 01000000b  }
  378.  
  379.                                                                 {  action for the new "bit (un)set" interface, TEFeatureFlag  }
  380.     teBitClear                    = 0;
  381.     teBitSet                    = 1;                            { set the selector bit }
  382.     teBitTest                    = -1;                            { no change; just return the current setting }
  383.  
  384.                                                                 { constants for identifying the routine that called FindWord  }
  385.     teWordSelect                = 4;                            { clickExpand to select word }
  386.     teWordDrag                    = 8;                            { clickExpand to drag new word }
  387.     teFromFind                    = 12;                            { FindLine called it ($0C) }
  388.     teFromRecal                    = 16;                            { RecalLines called it ($10)      obsolete  }
  389.  
  390.                                                                 { constants for identifying TEDoText selectors  }
  391.     teFind                        = 0;                            { TEDoText called for searching }
  392.     teHighlight                    = 1;                            { TEDoText called for highlighting }
  393.     teDraw                        = -1;                            { TEDoText called for drawing text }
  394.     teCaret                        = -2;                            { TEDoText called for drawing the caret }
  395.  
  396.  
  397.  
  398.  
  399. TYPE
  400.     Chars                                = PACKED ARRAY [0..32000] OF CHAR;
  401.     CharsPtr                            = ^Chars;
  402.     CharsHandle                            = ^CharsPtr;
  403.     StyleRunPtr = ^StyleRun;
  404.     StyleRun = RECORD
  405.         startChar:                INTEGER;                                { starting character position }
  406.         styleIndex:                INTEGER;                                { index in style table }
  407.     END;
  408.  
  409.     STElementPtr = ^STElement;
  410.     STElement = RECORD
  411.         stCount:                INTEGER;                                { number of runs in this style }
  412.         stHeight:                INTEGER;                                { line height }
  413.         stAscent:                INTEGER;                                { font ascent }
  414.         stFont:                    INTEGER;                                { font (family) number }
  415.         stFace:                    StyleField;                                { character Style }
  416.         stSize:                    INTEGER;                                { size in points }
  417.         stColor:                RGBColor;                                { absolute (RGB) color }
  418.     END;
  419.  
  420.     TEStyleTable                        = ARRAY [0..1776] OF STElement;
  421.     STPtr                                = ^TEStyleTable;
  422.     STHandle                            = ^STPtr;
  423.     LHElementPtr = ^LHElement;
  424.     LHElement = RECORD
  425.         lhHeight:                INTEGER;                                { maximum height in line }
  426.         lhAscent:                INTEGER;                                { maximum ascent in line }
  427.     END;
  428.  
  429.     LHTable                                = ARRAY [0..8000] OF LHElement;
  430.     LHPtr                                = ^LHTable;
  431.     LHHandle                            = ^LHPtr;
  432.     ScrpSTElementPtr = ^ScrpSTElement;
  433.     ScrpSTElement = RECORD
  434.         scrpStartChar:            LONGINT;                                { starting character position }
  435.         scrpHeight:                INTEGER;
  436.         scrpAscent:                INTEGER;
  437.         scrpFont:                INTEGER;
  438.         scrpFace:                StyleField;                                { unpacked byte }
  439.         scrpSize:                INTEGER;
  440.         scrpColor:                RGBColor;
  441.     END;
  442.  
  443. { ARRAY [0..1600] OF ScrpSTElement }
  444.     ScrpSTTable                            = ARRAY [0..1600] OF ScrpSTElement;
  445.     StScrpRecPtr = ^StScrpRec;
  446.     StScrpRec = RECORD
  447.         scrpNStyles:            INTEGER;                                { number of styles in scrap }
  448.         scrpStyleTab:            ScrpSTTable;                            { table of styles for scrap }
  449.     END;
  450.  
  451.     StScrpPtr                            = ^StScrpRec;
  452.     StScrpHandle                        = ^StScrpPtr;
  453.     NullStRecPtr = ^NullStRec;
  454.     NullStRec = RECORD
  455.         teReserved:                LONGINT;                                { reserved for future expansion }
  456.         nullScrap:                StScrpHandle;                            { handle to scrap style table }
  457.     END;
  458.  
  459.     NullStPtr                            = ^NullStRec;
  460.     NullStHandle                        = ^NullStPtr;
  461.     TEStyleRecPtr = ^TEStyleRec;
  462.     TEStyleRec = RECORD
  463.         nRuns:                    INTEGER;                                { number of style runs }
  464.         nStyles:                INTEGER;                                { size of style table }
  465.         styleTab:                STHandle;                                { handle to style table }
  466.         lhTab:                    LHHandle;                                { handle to line-height table }
  467.         teRefCon:                LONGINT;                                { reserved for application use }
  468.         nullStyle:                NullStHandle;                            { Handle to style set at null selection }
  469.         runs:                    ARRAY [0..8000] OF StyleRun;            { ARRAY [0..8000] OF StyleRun }
  470.     END;
  471.  
  472.     TEStylePtr                            = ^TEStyleRec;
  473.     TEStyleHandle                        = ^TEStylePtr;
  474.     TextStylePtr = ^TextStyle;
  475.     TextStyle = RECORD
  476.         tsFont:                    INTEGER;                                { font (family) number }
  477.         tsFace:                    StyleField;                                { character Style }
  478.         tsSize:                    INTEGER;                                { size in point }
  479.         tsColor:                RGBColor;                                { absolute (RGB) color }
  480.     END;
  481.  
  482.     TextStyleHandle                        = ^TextStylePtr;
  483.     TEIntHook                            = INTEGER;
  484.  
  485. CONST
  486.     uppHighHookProcInfo = $0000000F;
  487.     uppEOLHookProcInfo = $0000001F;
  488.     uppCaretHookProcInfo = $0000000F;
  489.     uppWidthHookProcInfo = $0000002F;
  490.     uppTextWidthHookProcInfo = $0000002F;
  491.     uppNWidthHookProcInfo = $0000003F;
  492.     uppDrawHookProcInfo = $0000004F;
  493.     uppHitTestHookProcInfo = $0000005F;
  494.     uppTEFindWordProcInfo = $0000006F;
  495.     uppTERecalcProcInfo = $0000009F;
  496.     uppTEDoTextProcInfo = $000000AF;
  497.     uppTEClickLoopProcInfo = $0000F812;
  498.     uppWordBreakProcInfo = $00029812;
  499.  
  500. FUNCTION NewHighHookProc(userRoutine: HighHookProcPtr): HighHookUPP;
  501.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  502.     INLINE $2E9F;
  503.     {$ENDC}
  504.  
  505. FUNCTION NewEOLHookProc(userRoutine: EOLHookProcPtr): EOLHookUPP;
  506.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  507.     INLINE $2E9F;
  508.     {$ENDC}
  509.  
  510. FUNCTION NewCaretHookProc(userRoutine: CaretHookProcPtr): CaretHookUPP;
  511.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  512.     INLINE $2E9F;
  513.     {$ENDC}
  514.  
  515. FUNCTION NewWidthHookProc(userRoutine: WidthHookProcPtr): WidthHookUPP;
  516.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  517.     INLINE $2E9F;
  518.     {$ENDC}
  519.  
  520. FUNCTION NewTextWidthHookProc(userRoutine: TextWidthHookProcPtr): TextWidthHookUPP;
  521.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  522.     INLINE $2E9F;
  523.     {$ENDC}
  524.  
  525. FUNCTION NewNWidthHookProc(userRoutine: NWidthHookProcPtr): NWidthHookUPP;
  526.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  527.     INLINE $2E9F;
  528.     {$ENDC}
  529.  
  530. FUNCTION NewDrawHookProc(userRoutine: DrawHookProcPtr): DrawHookUPP;
  531.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  532.     INLINE $2E9F;
  533.     {$ENDC}
  534.  
  535. FUNCTION NewHitTestHookProc(userRoutine: HitTestHookProcPtr): HitTestHookUPP;
  536.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  537.     INLINE $2E9F;
  538.     {$ENDC}
  539.  
  540. FUNCTION NewTEFindWordProc(userRoutine: TEFindWordProcPtr): TEFindWordUPP;
  541.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  542.     INLINE $2E9F;
  543.     {$ENDC}
  544.  
  545. FUNCTION NewTERecalcProc(userRoutine: TERecalcProcPtr): TERecalcUPP;
  546.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  547.     INLINE $2E9F;
  548.     {$ENDC}
  549.  
  550. FUNCTION NewTEDoTextProc(userRoutine: TEDoTextProcPtr): TEDoTextUPP;
  551.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  552.     INLINE $2E9F;
  553.     {$ENDC}
  554.  
  555. FUNCTION NewTEClickLoopProc(userRoutine: TEClickLoopProcPtr): TEClickLoopUPP;
  556.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  557.     INLINE $2E9F;
  558.     {$ENDC}
  559.  
  560. FUNCTION NewWordBreakProc(userRoutine: WordBreakProcPtr): WordBreakUPP;
  561.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  562.     INLINE $2E9F;
  563.     {$ENDC}
  564.  
  565. PROCEDURE CallHighHookProc({CONST}VAR r: Rect; pTE: TEPtr; userRoutine: HighHookUPP);
  566.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  567.     {To be implemented:  Glue to move parameters into registers.}
  568.     {$ENDC}
  569.  
  570. FUNCTION CallEOLHookProc(theChar: ByteParameter; pTE: TEPtr; hTE: TEHandle; userRoutine: EOLHookUPP): BOOLEAN;
  571.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  572.     {To be implemented:  Glue to move parameters into registers.}
  573.     {$ENDC}
  574.  
  575. PROCEDURE CallCaretHookProc({CONST}VAR r: Rect; pTE: TEPtr; userRoutine: CaretHookUPP);
  576.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  577.     {To be implemented:  Glue to move parameters into registers.}
  578.     {$ENDC}
  579.  
  580. FUNCTION CallWidthHookProc(textLen: UInt16; textOffset: UInt16; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; userRoutine: WidthHookUPP): UInt16;
  581.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  582.     {To be implemented:  Glue to move parameters into registers.}
  583.     {$ENDC}
  584.  
  585. FUNCTION CallTextWidthHookProc(textLen: UInt16; textOffset: UInt16; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; userRoutine: TextWidthHookUPP): UInt16;
  586.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  587.     {To be implemented:  Glue to move parameters into registers.}
  588.     {$ENDC}
  589.  
  590. FUNCTION CallNWidthHookProc(styleRunLen: UInt16; styleRunOffset: UInt16; slop: INTEGER; direction: INTEGER; textBufferPtr: UNIV Ptr; VAR lineStart: INTEGER; pTE: TEPtr; hTE: TEHandle; userRoutine: NWidthHookUPP): UInt16;
  591.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  592.     {To be implemented:  Glue to move parameters into registers.}
  593.     {$ENDC}
  594.  
  595. PROCEDURE CallDrawHookProc(textOffset: UInt16; drawLen: UInt16; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; userRoutine: DrawHookUPP);
  596.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  597.     {To be implemented:  Glue to move parameters into registers.}
  598.     {$ENDC}
  599.  
  600. FUNCTION CallHitTestHookProc(styleRunLen: UInt16; styleRunOffset: UInt16; slop: UInt16; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; VAR pixelWidth: UInt16; VAR charOffset: UInt16; VAR pixelInChar: BOOLEAN; userRoutine: HitTestHookUPP): BOOLEAN;
  601.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  602.     {To be implemented:  Glue to move parameters into registers.}
  603.     {$ENDC}
  604.  
  605. PROCEDURE CallTEFindWordProc(currentPos: UInt16; caller: INTEGER; pTE: TEPtr; hTE: TEHandle; VAR wordStart: UInt16; VAR wordEnd: UInt16; userRoutine: TEFindWordUPP);
  606.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  607.     {To be implemented:  Glue to move parameters into registers.}
  608.     {$ENDC}
  609.  
  610. PROCEDURE CallTERecalcProc(pTE: TEPtr; changeLength: UInt16; VAR lineStart: UInt16; VAR firstChar: UInt16; VAR lastChar: UInt16; userRoutine: TERecalcUPP);
  611.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  612.     {To be implemented:  Glue to move parameters into registers.}
  613.     {$ENDC}
  614.  
  615. PROCEDURE CallTEDoTextProc(pTE: TEPtr; firstChar: UInt16; lastChar: UInt16; selector: INTEGER; VAR currentGrafPort: GrafPtr; VAR charPosition: INTEGER; userRoutine: TEDoTextUPP);
  616.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  617.     {To be implemented:  Glue to move parameters into registers.}
  618.     {$ENDC}
  619.  
  620. FUNCTION CallTEClickLoopProc(pTE: TEPtr; userRoutine: TEClickLoopUPP): BOOLEAN;
  621.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  622.     {To be implemented:  Glue to move parameters into registers.}
  623.     {$ENDC}
  624.  
  625. FUNCTION CallWordBreakProc(text: Ptr; charPos: INTEGER; userRoutine: WordBreakUPP): BOOLEAN;
  626.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  627.     {To be implemented:  Glue to move parameters into registers.}
  628.     {$ENDC}
  629.  
  630. CONST
  631.                                                                 {  feature bit 4 for TEFeatureFlag no longer in use  }
  632.     teFUseTextServices            = 4;                            { 00010000b  }
  633.  
  634.  
  635. FUNCTION TEScrapHandle: Handle;
  636.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  637.     INLINE $2EB8, $0AB4;
  638.     {$ENDC}
  639.  
  640. FUNCTION TEGetScrapLength: LONGINT;
  641.  
  642. PROCEDURE TEInit;
  643.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  644.     INLINE $A9CC;
  645.     {$ENDC}
  646. FUNCTION TENew({CONST}VAR destRect: Rect; {CONST}VAR viewRect: Rect): TEHandle;
  647.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  648.     INLINE $A9D2;
  649.     {$ENDC}
  650. PROCEDURE TEDispose(hTE: TEHandle);
  651.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  652.     INLINE $A9CD;
  653.     {$ENDC}
  654. PROCEDURE TESetText(text: UNIV Ptr; length: LONGINT; hTE: TEHandle);
  655.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  656.     INLINE $A9CF;
  657.     {$ENDC}
  658. FUNCTION TEGetText(hTE: TEHandle): CharsHandle;
  659.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  660.     INLINE $A9CB;
  661.     {$ENDC}
  662. PROCEDURE TEIdle(hTE: TEHandle);
  663.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  664.     INLINE $A9DA;
  665.     {$ENDC}
  666. PROCEDURE TESetSelect(selStart: LONGINT; selEnd: LONGINT; hTE: TEHandle);
  667.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  668.     INLINE $A9D1;
  669.     {$ENDC}
  670. PROCEDURE TEActivate(hTE: TEHandle);
  671.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  672.     INLINE $A9D8;
  673.     {$ENDC}
  674. PROCEDURE TEDeactivate(hTE: TEHandle);
  675.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  676.     INLINE $A9D9;
  677.     {$ENDC}
  678. PROCEDURE TEKey(key: CharParameter; hTE: TEHandle);
  679.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  680.     INLINE $A9DC;
  681.     {$ENDC}
  682. PROCEDURE TECut(hTE: TEHandle);
  683.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  684.     INLINE $A9D6;
  685.     {$ENDC}
  686. PROCEDURE TECopy(hTE: TEHandle);
  687.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  688.     INLINE $A9D5;
  689.     {$ENDC}
  690. PROCEDURE TEPaste(hTE: TEHandle);
  691.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  692.     INLINE $A9DB;
  693.     {$ENDC}
  694. PROCEDURE TEDelete(hTE: TEHandle);
  695.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  696.     INLINE $A9D7;
  697.     {$ENDC}
  698. PROCEDURE TEInsert(text: UNIV Ptr; length: LONGINT; hTE: TEHandle);
  699.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  700.     INLINE $A9DE;
  701.     {$ENDC}
  702. PROCEDURE TESetAlignment(just: INTEGER; hTE: TEHandle);
  703.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  704.     INLINE $A9DF;
  705.     {$ENDC}
  706. PROCEDURE TEUpdate({CONST}VAR rUpdate: Rect; hTE: TEHandle);
  707.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  708.     INLINE $A9D3;
  709.     {$ENDC}
  710. PROCEDURE TETextBox(text: UNIV Ptr; length: LONGINT; {CONST}VAR box: Rect; just: INTEGER);
  711.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  712.     INLINE $A9CE;
  713.     {$ENDC}
  714. PROCEDURE TEScroll(dh: INTEGER; dv: INTEGER; hTE: TEHandle);
  715.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  716.     INLINE $A9DD;
  717.     {$ENDC}
  718. PROCEDURE TESelView(hTE: TEHandle);
  719.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  720.     INLINE $A811;
  721.     {$ENDC}
  722. PROCEDURE TEPinScroll(dh: INTEGER; dv: INTEGER; hTE: TEHandle);
  723.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  724.     INLINE $A812;
  725.     {$ENDC}
  726. PROCEDURE TEAutoView(fAuto: BOOLEAN; hTE: TEHandle);
  727.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  728.     INLINE $A813;
  729.     {$ENDC}
  730. PROCEDURE TECalText(hTE: TEHandle);
  731.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  732.     INLINE $A9D0;
  733.     {$ENDC}
  734. FUNCTION TEGetOffset(pt: Point; hTE: TEHandle): INTEGER;
  735.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  736.     INLINE $A83C;
  737.     {$ENDC}
  738. FUNCTION TEGetPoint(offset: INTEGER; hTE: TEHandle): Point;
  739.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  740.     INLINE $3F3C, $0008, $A83D;
  741.     {$ENDC}
  742. PROCEDURE TEClick(pt: Point; fExtend: BOOLEAN; h: TEHandle);
  743.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  744.     INLINE $A9D4;
  745.     {$ENDC}
  746. FUNCTION TEStyleNew({CONST}VAR destRect: Rect; {CONST}VAR viewRect: Rect): TEHandle;
  747.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  748.     INLINE $A83E;
  749.     {$ENDC}
  750. PROCEDURE TESetStyleHandle(theHandle: TEStyleHandle; hTE: TEHandle);
  751.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  752.     INLINE $3F3C, $0005, $A83D;
  753.     {$ENDC}
  754. FUNCTION TEGetStyleHandle(hTE: TEHandle): TEStyleHandle;
  755.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  756.     INLINE $3F3C, $0004, $A83D;
  757.     {$ENDC}
  758. PROCEDURE TEGetStyle(offset: INTEGER; VAR theStyle: TextStyle; VAR lineHeight: INTEGER; VAR fontAscent: INTEGER; hTE: TEHandle);
  759.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  760.     INLINE $3F3C, $0003, $A83D;
  761.     {$ENDC}
  762. PROCEDURE TEStylePaste(hTE: TEHandle);
  763.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  764.     INLINE $3F3C, $0000, $A83D;
  765.     {$ENDC}
  766. PROCEDURE TESetStyle(mode: INTEGER; {CONST}VAR newStyle: TextStyle; fRedraw: BOOLEAN; hTE: TEHandle);
  767.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  768.     INLINE $3F3C, $0001, $A83D;
  769.     {$ENDC}
  770. PROCEDURE TEReplaceStyle(mode: INTEGER; {CONST}VAR oldStyle: TextStyle; {CONST}VAR newStyle: TextStyle; fRedraw: BOOLEAN; hTE: TEHandle);
  771.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  772.     INLINE $3F3C, $0002, $A83D;
  773.     {$ENDC}
  774. FUNCTION TEGetStyleScrapHandle(hTE: TEHandle): StScrpHandle;
  775.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  776.     INLINE $3F3C, $0006, $A83D;
  777.     {$ENDC}
  778. PROCEDURE TEStyleInsert(text: UNIV Ptr; length: LONGINT; hST: StScrpHandle; hTE: TEHandle);
  779.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  780.     INLINE $3F3C, $0007, $A83D;
  781.     {$ENDC}
  782. FUNCTION TEGetHeight(endLine: LONGINT; startLine: LONGINT; hTE: TEHandle): LONGINT;
  783.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  784.     INLINE $3F3C, $0009, $A83D;
  785.     {$ENDC}
  786. FUNCTION TEContinuousStyle(VAR mode: INTEGER; VAR aStyle: TextStyle; hTE: TEHandle): BOOLEAN;
  787.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  788.     INLINE $3F3C, $000A, $A83D;
  789.     {$ENDC}
  790. PROCEDURE TEUseStyleScrap(rangeStart: LONGINT; rangeEnd: LONGINT; newStyles: StScrpHandle; fRedraw: BOOLEAN; hTE: TEHandle);
  791.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  792.     INLINE $3F3C, $000B, $A83D;
  793.     {$ENDC}
  794. PROCEDURE TECustomHook(which: TEIntHook; VAR addr: UniversalProcPtr; hTE: TEHandle);
  795.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  796.     INLINE $3F3C, $000C, $A83D;
  797.     {$ENDC}
  798. FUNCTION TENumStyles(rangeStart: LONGINT; rangeEnd: LONGINT; hTE: TEHandle): LONGINT;
  799.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  800.     INLINE $3F3C, $000D, $A83D;
  801.     {$ENDC}
  802. FUNCTION TEFeatureFlag(feature: INTEGER; action: INTEGER; hTE: TEHandle): INTEGER;
  803.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  804.     INLINE $3F3C, $000E, $A83D;
  805.     {$ENDC}
  806. FUNCTION TEGetHiliteRgn(region: RgnHandle; hTE: TEHandle): OSErr;
  807.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  808.     INLINE $3F3C, $000F, $A83D;
  809.     {$ENDC}
  810. PROCEDURE TESetScrapLength(length: LONGINT);
  811. FUNCTION TEFromScrap: OSErr;
  812. FUNCTION TEToScrap: OSErr;
  813. PROCEDURE TESetClickLoop(clikProc: TEClickLoopUPP; hTE: TEHandle);
  814. PROCEDURE TESetWordBreak(wBrkProc: WordBreakUPP; hTE: TEHandle);
  815.  
  816. {$IFC OLDROUTINENAMES }
  817. PROCEDURE TESetJust(just: INTEGER; hTE: TEHandle);
  818.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  819.     INLINE $A9DF;
  820.     {$ENDC}
  821. PROCEDURE TextBox(text: UNIV Ptr; length: LONGINT; {CONST}VAR box: Rect; just: INTEGER);
  822.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  823.     INLINE $A9CE;
  824.     {$ENDC}
  825. FUNCTION TEStylNew({CONST}VAR destRect: Rect; {CONST}VAR viewRect: Rect): TEHandle;
  826.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  827.     INLINE $A83E;
  828.     {$ENDC}
  829. PROCEDURE SetStylHandle(theHandle: TEStyleHandle; hTE: TEHandle);
  830.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  831.     INLINE $3F3C, $0005, $A83D;
  832.     {$ENDC}
  833. PROCEDURE SetStyleHandle(theHandle: TEStyleHandle; hTE: TEHandle);
  834.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  835.     INLINE $3F3C, $0005, $A83D;
  836.     {$ENDC}
  837. FUNCTION GetStylHandle(hTE: TEHandle): TEStyleHandle;
  838.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  839.     INLINE $3F3C, $0004, $A83D;
  840.     {$ENDC}
  841. FUNCTION GetStyleHandle(hTE: TEHandle): TEStyleHandle;
  842.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  843.     INLINE $3F3C, $0004, $A83D;
  844.     {$ENDC}
  845. PROCEDURE TEStylPaste(hTE: TEHandle);
  846.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  847.     INLINE $3F3C, $0000, $A83D;
  848.     {$ENDC}
  849. FUNCTION GetStylScrap(hTE: TEHandle): StScrpHandle;
  850.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  851.     INLINE $3F3C, $0006, $A83D;
  852.     {$ENDC}
  853. FUNCTION GetStyleScrap(hTE: TEHandle): StScrpHandle;
  854.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  855.     INLINE $3F3C, $0006, $A83D;
  856.     {$ENDC}
  857. PROCEDURE SetStylScrap(rangeStart: LONGINT; rangeEnd: LONGINT; newStyles: StScrpHandle; fRedraw: BOOLEAN; hTE: TEHandle);
  858.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  859.     INLINE $3F3C, $000B, $A83D;
  860.     {$ENDC}
  861. PROCEDURE SetStyleScrap(rangeStart: LONGINT; rangeEnd: LONGINT; newStyles: StScrpHandle; fRedraw: BOOLEAN; hTE: TEHandle);
  862.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  863.     INLINE $3F3C, $000B, $A83D;
  864.     {$ENDC}
  865. PROCEDURE TEStylInsert(text: UNIV Ptr; length: LONGINT; hST: StScrpHandle; hTE: TEHandle);
  866.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  867.     INLINE $3F3C, $0007, $A83D;
  868.     {$ENDC}
  869. PROCEDURE TESetScrapLen(length: LONGINT);
  870. FUNCTION TEGetScrapLen: LONGINT;
  871. PROCEDURE SetClikLoop(clikProc: TEClickLoopUPP; hTE: TEHandle);
  872. PROCEDURE SetWordBreak(wBrkProc: WordBreakUPP; hTE: TEHandle);
  873. {$ENDC}  {OLDROUTINENAMES}
  874.  
  875. {$ALIGN RESET}
  876. {$POP}
  877.  
  878. {$SETC UsingIncludes := TextEditIncludes}
  879.  
  880. {$ENDC} {__TEXTEDIT__}
  881.  
  882. {$IFC NOT UsingIncludes}
  883.  END.
  884. {$ENDC}
  885.